home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / program / 316 / libsrc / crt0.s < prev    next >
Encoding:
Text File  |  1988-10-20  |  6.3 KB  |  228 lines
  1. |
  2. |        Cross Development System for Atari ST 
  3. |      Copyright (c) 1988, Memorial University of Newfoundland
  4. |
  5. |  C start-up routine.  Has several tasks to do:
  6. |    release unneeded memory to the system
  7. |    set up stack
  8. |    set up argc, argv, and envp
  9. |    set up an address trap handler for bsr.l instructions
  10. |  Also defines _exit() so the address error handler can be restored
  11. |
  12. | $Header: crt0.s,v 1.3 88/02/03 20:23:26 m68k Exp $
  13. |
  14. | $Log:    crt0.s,v $
  15. | Revision 1.3  88/02/03  20:23:26  m68k
  16. | Added __in_trap flag - see atari/alarm()
  17. | 
  18. | Revision 1.2  88/01/29  17:24:37  m68k
  19. | Re-wrote the argument parsing stuff
  20. | Calls exit() instead of _exit()
  21. | uses Setvec() trap instead of Super()/mov/Super() to change the ae trap
  22. | stack now has initial size of 8k (up from 2)
  23. | 
  24. |
  25.     .globl    __start
  26.     .globl    __exit
  27.     .globl    __base
  28.     .globl    _environ
  29.     .globl    _main
  30.     .globl    _errno
  31.     .globl    __in_trap
  32.  
  33.     .comm    __base,4
  34.     .comm    __stksize,4
  35.     .comm    _environ,4
  36.     .comm    _errno,4
  37.     .comm    old_aet,4
  38.     .comm    __in_trap,1
  39.  
  40.     .text
  41.  
  42. __start:
  43.     movl    a7@(4), a5
  44.     movl    a5, __base
  45.  
  46.     | set up envp[] and argv[] stuff
  47.     movl    a5@(0x18), a1        | envp = basepage->bss_address
  48.     addl    a5@(0x1c), a1        |    + basepage->bss_size;
  49.     movl    a1, _environ        | _environ = envp;
  50.     movl    a5@(0x2c), a2        | ep = basepage->envp;
  51. L0:    tstb    a2@            | while (*ep) {
  52.     beq    L3            |
  53.     movl    a2, a1@+        |    *envp++ = ep;
  54. L2:    tstb    a2@+            |    while (*ep++)
  55.     bne    L2            |        ;
  56.     bra    L0            | }
  57. L3:    clrl    a1@+            | *envp++ = (char *) 0; 
  58.     |  From here down to 0: is only relivent if you are using the mark
  59.     | williams shell, which passes the arguments in the environment as
  60.     | well as the base page (also passes argv[0]).  The start of the
  61.     | arguments is marked by a env variable by the name ARGV (which has
  62.     | some i/o vector stuff in it - not used).
  63.     movl    _environ, a3        |
  64. L1:    tstl    a3@            | for (s = environ ; *s ; s++)
  65.     beq    L7            |
  66.     movl    a3@+, a4        |    if (strncmp(*s, "ARGV=", 5))
  67.     cmpb    #0x41, a4@+        |
  68.     bne    L1            |
  69.     cmpb    #0x52, a4@+        |
  70.     bne    L1            |
  71.     cmpb    #0x47, a4@+        |
  72.     bne    L1            |
  73.     cmpb    #0x56, a4@+        |
  74.     bne    L1            |
  75.     cmpb    #0x3d, a4@+        |
  76.     bne    L1            |    {
  77.     clrl    a3@-            |        *--s = 0;
  78.     movl    a3, a2            |        argv = s + 2;
  79.     addql    #0x4, a2        |
  80.     movl    a1, a0            |        
  81.     movl    a1, d3            |        argc = (&a1[1] - argv)
  82.     subl    a2, d3            |            / sizeof(long);    
  83.     subql    #0x4, d3        |
  84.     asrl    #0x2, d3        |        break;
  85.     bra    L6            |    }
  86. L7:                    | /* a1: envp -> argbuf */
  87.     movl    a1, a0            | argv = argbuf
  88.     addl    #128, a0        |     + sizeof(baseage->cmdline);
  89.     clrw    a0@+            | *((short)argv)++ = 0;
  90.     movl    a1, d1            | argstart = argbuf;
  91.     movl    a0, a2            | saveargv = argv;
  92. |    movew    #1, d3            | argc = 1;
  93.     movel    #1, d3            | .. jrd
  94.     movl    #arg0, a0@+        | *argv++ = "arg0.prg";
  95.     movl    #0x80, a3        | cmdline = basepage->cmdline;
  96.     addl    a5, a3            |
  97.     moveb    a3@, d0            | /* # of chars in cmdline buf (128) */
  98. L8:    subqb    #1, d0            | while (d0-- > 0)
  99. |    ble    L9            |
  100.     blt    L9            | .. jrd
  101.     addql    #1, a3            |     if (*++cmdline == 0)
  102.     tstb    a3@            |     {
  103.     bne    L11            |
  104. L9:    cmpl    a1, d1            |        if (argbuf != argstart)
  105.     beq    L10            |        {
  106.     clrb    a1@+            |            *argbuf++ = '\0';
  107.     movl    d1, a0@+        |            *argv++ = argstart;
  108. |    addqw    #1, d3            |            argc++;
  109.     addql    #1, d3
  110.                     |        }
  111. L10:    clrl    a0@+            |        *argv++ = (char *) NULL;
  112.     bra    L6            |         break;
  113. L11:    cmpb    #0x20, a3@        |     } else if (*cmdline == ' ')
  114.     bne    L12            |     {
  115. |    addqw    #1, d3            |        argc++;
  116.     addql    #1,d3            | .. jrd
  117.     movl    d1, a0@+        |        *argv++ = argstart;
  118.     clrb    a1@+            |        *argbuf++ = '\0';
  119.     movl    a1, d1            |        argstart = argbuf;
  120.     bra    L8            |     } else
  121. L12:    moveb    a3@, a1@+        |        *argbuf++ = *cmdline;
  122.     bra    L8
  123.  
  124. L6:
  125.     movl    a0, a3            | reserve = argv - __base;
  126.     subl    a5, a3
  127.     tstl    __stksize        | if (!__stksize)
  128.     bne    L13            |
  129.     movl    #0x2000, __stksize    |    __stksize = 8 * 1024;
  130. L13:    addl    __stksize, a3        | reserve += __stksize;
  131.     movl    a3, d1
  132.     addl    a5, d1            | compute stack top
  133.     andl    #-2, d1            | even boundry
  134.     movl    d1, sp            | set up user stack
  135.  
  136.     movl    a3, sp@-
  137.     movl    a5, sp@-
  138.     clrw    sp@-
  139.     movw    #0x4a, sp@-
  140.     bset    #0, __in_trap
  141.     trap    #1            | release excess storage
  142.     bclr    #0, __in_trap
  143.     addl    #12, sp
  144.  
  145.     movl    _environ, sp@-        | push saveenvp
  146.     movl    a2, sp@-        | push saveargv
  147. |    movw    d3, sp@-        | push argc
  148.     movel    d3,sp@-            | .. jrd
  149.  
  150.     subl    a6, a6            | clear link reg - why I don't know
  151.  
  152.     | here we set up a trap handler for address errors - this is used in
  153.     | doing long branches and long bsrs (see comments in Leat()).
  154.  
  155.     movl    #aet, sp@-    | set address error vector to our handler
  156.     movew    #0xc, sp@-
  157.     movew    #0x5, sp@-
  158.     bset    #0, __in_trap
  159.     trap    #13
  160.     bclr    #0, __in_trap
  161.     addql    #0x8, sp
  162.     movl    d0, old_aet    | save old trap handler
  163.  
  164. |    jsr    _main
  165.     jsr    __main        | -- jrd.  call the standard wrapper fun
  166.     movew    d0, sp@-
  167.     jsr    _exit        | _exit calls __exit
  168.     | Not reached
  169.  
  170. |
  171. | _exit is here because it has to restore the old address error vector
  172. |
  173. __exit:
  174.     movl    old_aet, sp@-    | restore old address trap before we exit
  175.     movew    #0xc, sp@-
  176.     movew    #0x5, sp@-
  177.     bset    #0, __in_trap
  178.     trap    #13
  179.     bclr    #0, __in_trap
  180.     addql    #0x8, sp
  181. |    movew    sp@(0x4), sp@-    | .. jrd
  182.     movel    sp@(4),d0
  183.     movew    d0,sp@-
  184.     movew    #0x4c, sp@-
  185.     bset    #0, __in_trap
  186.     trap    #1
  187.     | The End.
  188.  
  189. |  This is a trap handler for address errors.  It is used in doing long
  190. | branches and long bsrs.  It looks to see if a long branch (0x6?ff) caused
  191. | the trap and if the destination is valid (not an odd address).  If so
  192. | the branch is taken and we return, otherwise, we call the old address
  193. | trapper.
  194. aet:
  195.     | d0, and a1 used 0x8080/101
  196.     | exp_frame is distance from top of stack to exception frame
  197.     Lexp_frame = 8            | 2 * sizeof(register)
  198.     moveml    #0x8080, sp@-        | save registers used
  199.     movw    sp@(Lexp_frame+6), d0    | the bad instruction
  200.     andw    #0xf0ff, d0
  201.     cmpw    #0x60ff, d0        | is a b?? instruction?
  202.     jne    L20            | nop, call old ae trap
  203.  
  204.     movl    sp@(Lexp_frame+10), a0    | the pc (currently bewtixt branch)
  205.     addql    #1, a0            | increment to long offset
  206.     addl    a0@, a0            | calculate new pc
  207.     movl    a0, d0
  208.     andb    #1, d0            | are we still an odd address?
  209.     jne    L20            | yep, get out.
  210.  
  211.     movl    a0, sp@(Lexp_frame+10)    | put new pc into the stack frame
  212.     cmpw    #0x61ff, sp@(Lexp_frame+6)    | if this is a bsrl
  213.     jne    L21            |  we need to fix up the return
  214.     movl    usp, a0            |  address on the user stack
  215.     addql    #4, a0@
  216. L21:
  217.     moveml    sp@+, #0x0101        | restore regs
  218.     addql    #8,sp            | pop part of stack frame
  219.     rte
  220.  
  221. L20:
  222.     moveml    sp@+, #0x0101
  223.     movl    old_aet, sp@(-4)    | done this way so no regs get mussed up
  224.     jmp    sp@(-4)
  225.  
  226. .data
  227. arg0:    .ascii "arg0\0"
  228.